// 商品服务层
const ProductsDAO = require('../dao/products.dao.js');
const productsDAO = new ProductsDAO();

class ProductService {
  /**
   * 构造函数
   */
  constructor() {}

  /**
   * 创建商品
   * @param {Object} productData - 商品数据
   * @returns {Promise} 创建结果
   */
  async createProduct(productData) {
    try {
      // 参数验证
      if (!productData.name || !productData.category_id || !productData.current_price || !productData.stock) {
        return {
          success: false,
          error: '商品名称、分类ID、现价和库存为必填项'
        };
      }

      // 价格验证
      if (productData.current_price < 0 || productData.original_price < 0) {
        return {
          success: false,
          error: '价格不能为负数'
        };
      }

      // 库存验证
      if (productData.stock < 0) {
        return {
          success: false,
          error: '库存不能为负数'
        };
      }

      // 调用DAO层添加商品
      const result = await productsDAO.addProduct(productData);
      return result;
    } catch (error) {
      console.error('创建商品失败:', error);
      return {
        success: false,
        error: error.message || '创建商品失败'
      };
    }
  }

  /**
   * 获取商品详情
   * @param {String} id - 商品ID
   * @returns {Promise} 商品详情
   */
  async getProductDetail(id) {
    try {
      // 参数验证
      if (!id) {
        return {
          success: false,
          error: '商品ID不能为空'
        };
      }

      // 调用DAO层获取商品
      const result = await productsDAO.getProductById(id);
      
      // 如果获取成功且商品存在，增加浏览量
      if (result.success && result.data) {
        // 异步增加浏览量，不影响当前响应
        productsDAO.increaseViewCount(id).catch(err => {
          console.warn('增加浏览量失败:', err);
        });
      }

      return result;
    } catch (error) {
      console.error('获取商品详情失败:', error);
      return {
        success: false,
        error: error.message || '获取商品详情失败'
      };
    }
  }

  /**
   * 更新商品信息
   * @param {String} id - 商品ID
   * @param {Object} updateData - 更新数据
   * @returns {Promise} 更新结果
   */
  async updateProduct(id, updateData) {
    try {
      // 参数验证
      if (!id) {
        return {
          success: false,
          error: '商品ID不能为空'
        };
      }

      // 验证更新数据
      if (updateData.current_price !== undefined && updateData.current_price < 0) {
        return {
          success: false,
          error: '现价不能为负数'
        };
      }
      if (updateData.original_price !== undefined && updateData.original_price < 0) {
        return {
          success: false,
          error: '原价不能为负数'
        };
      }
      if (updateData.stock !== undefined && updateData.stock < 0) {
        return {
          success: false,
          error: '库存不能为负数'
        };
      }

      // 检查商品是否存在
      const productResult = await productsDAO.getProductById(id);
      if (!productResult.success || !productResult.data) {
        return {
          success: false,
          error: '商品不存在'
        };
      }

      // 调用DAO层更新商品
      const result = await productsDAO.updateProduct(id, updateData);
      return result;
    } catch (error) {
      console.error('更新商品失败:', error);
      return {
        success: false,
        error: error.message || '更新商品失败'
      };
    }
  }

  /**
   * 删除商品
   * @param {String} id - 商品ID
   * @returns {Promise} 删除结果
   */
  async deleteProduct(id) {
    try {
      // 参数验证
      if (!id) {
        return {
          success: false,
          error: '商品ID不能为空'
        };
      }

      // 检查商品是否存在
      const productResult = await productsDAO.getProductById(id);
      if (!productResult.success || !productResult.data) {
        return {
          success: false,
          error: '商品不存在'
        };
      }

      // 调用DAO层删除商品
      const result = await productsDAO.deleteProduct(id);
      return result;
    } catch (error) {
      console.error('删除商品失败:', error);
      return {
        success: false,
        error: error.message || '删除商品失败'
      };
    }
  }

  /**
   * 获取商品列表
   * @param {Object} queryParams - 查询参数
   * @returns {Promise} 商品列表
   */
  async getProductList(queryParams = {}) {
    try {
      // 构建查询参数
      const query = {
        category_id: queryParams.category_id,
        status: queryParams.status !== undefined ? parseInt(queryParams.status) : undefined,
        is_distribution: queryParams.is_distribution !== undefined ? parseInt(queryParams.is_distribution) : undefined,
        keyword: queryParams.keyword,
        min_price: queryParams.min_price !== undefined ? parseFloat(queryParams.min_price) : undefined,
        max_price: queryParams.max_price !== undefined ? parseFloat(queryParams.max_price) : undefined,
        sort_field: queryParams.sort_field || 'create_time',
        sort_order: queryParams.sort_order || 'desc'
      };

      // 分页参数
      const page = queryParams.page ? parseInt(queryParams.page) : 1;
      const size = queryParams.size ? parseInt(queryParams.size) : 10;

      // 参数验证
      if (page < 1 || size < 1) {
        return {
          success: false,
          error: '页码和每页大小必须大于0'
        };
      }

      // 调用DAO层查询商品列表
      const result = await productsDAO.queryProducts(query, page, size);
      return result;
    } catch (error) {
      console.error('获取商品列表失败:', error);
      return {
        success: false,
        error: error.message || '获取商品列表失败'
      };
    }
  }

  /**
   * 上下架商品
   * @param {String} id - 商品ID
   * @param {Number} status - 状态(0下架/1上架)
   * @returns {Promise} 操作结果
   */
  async changeProductStatus(id, status) {
    try {
      // 参数验证
      if (!id) {
        return {
          success: false,
          error: '商品ID不能为空'
        };
      }

      if (status !== 0 && status !== 1) {
        return {
          success: false,
          error: '状态值必须为0或1'
        };
      }

      // 调用DAO层更新状态
      const result = await productsDAO.updateProduct(id, { status });
      return result;
    } catch (error) {
      console.error('修改商品状态失败:', error);
      return {
        success: false,
        error: error.message || '修改商品状态失败'
      };
    }
  }

  /**
   * 批量上下架商品
   * @param {Array} ids - 商品ID数组
   * @param {Number} status - 状态(0下架/1上架)
   * @returns {Promise} 操作结果
   */
  async batchChangeStatus(ids, status) {
    try {
      // 参数验证
      if (!Array.isArray(ids) || ids.length === 0) {
        return {
          success: false,
          error: '商品ID数组不能为空'
        };
      }

      if (status !== 0 && status !== 1) {
        return {
          success: false,
          error: '状态值必须为0或1'
        };
      }

      // 调用DAO层批量更新状态
      const result = await productsDAO.batchUpdateStatus(ids, status);
      return result;
    } catch (error) {
      console.error('批量修改商品状态失败:', error);
      return {
        success: false,
        error: error.message || '批量修改商品状态失败'
      };
    }
  }

  /**
   * 商品库存操作
   * @param {String} id - 商品ID
   * @param {Number} quantity - 数量
   * @param {String} operation - 操作类型(increase/decrease)
   * @returns {Promise} 操作结果
   */
  async operateStock(id, quantity, operation) {
    try {
      // 参数验证
      if (!id) {
        return {
          success: false,
          error: '商品ID不能为空'
        };
      }

      if (!quantity || quantity <= 0 || !Number.isInteger(quantity)) {
        return {
          success: false,
          error: '数量必须为正整数'
        };
      }

      if (operation !== 'increase' && operation !== 'decrease') {
        return {
          success: false,
          error: '操作类型必须为increase或decrease'
        };
      }

      let result;
      if (operation === 'increase') {
        // 增加库存
        result = await productsDAO.increaseStock(id, quantity);
      } else {
        // 减少库存并增加销量
        result = await productsDAO.decreaseStockAndIncreaseSales(id, quantity);
      }

      return result;
    } catch (error) {
      console.error('库存操作失败:', error);
      return {
        success: false,
        error: error.message || '库存操作失败'
      };
    }
  }

  /**
   * 获取热门商品
   * @param {Number} limit - 返回数量
   * @returns {Promise} 热门商品列表
   */
  async getHotProducts(limit = 10) {
    try {
      // 参数验证
      if (limit <= 0 || !Number.isInteger(limit)) {
        return {
          success: false,
          error: '限制数量必须为正整数'
        };
      }

      // 调用DAO层查询销量最高的商品
      const query = {
        status: 1, // 只查询上架商品
        sort_field: 'sales',
        sort_order: 'desc'
      };

      const result = await productsDAO.queryProducts(query, 1, limit);
      return result;
    } catch (error) {
      console.error('获取热门商品失败:', error);
      return {
        success: false,
        error: error.message || '获取热门商品失败'
      };
    }
  }

  /**
   * 获取最新商品
   * @param {Number} limit - 返回数量
   * @returns {Promise} 最新商品列表
   */
  async getNewProducts(limit = 10) {
    try {
      // 参数验证
      if (limit <= 0 || !Number.isInteger(limit)) {
        return {
          success: false,
          error: '限制数量必须为正整数'
        };
      }

      // 调用DAO层查询最新上架的商品
      const query = {
        status: 1, // 只查询上架商品
        sort_field: 'create_time',
        sort_order: 'desc'
      };

      const result = await productsDAO.queryProducts(query, 1, limit);
      return result;
    } catch (error) {
      console.error('获取最新商品失败:', error);
      return {
        success: false,
        error: error.message || '获取最新商品失败'
      };
    }
  }

  /**
   * 获取分销商品
   * @param {Object} queryParams - 查询参数
   * @returns {Promise} 分销商品列表
   */
  async getDistributionProducts(queryParams = {}) {
    try {
      // 构建查询参数，确保只查询分销商品
      const query = {
        ...queryParams,
        is_distribution: 1, // 只查询分销商品
        status: 1 // 只查询上架商品
      };

      // 分页参数
      const page = queryParams.page ? parseInt(queryParams.page) : 1;
      const size = queryParams.size ? parseInt(queryParams.size) : 10;

      // 参数验证
      if (page < 1 || size < 1) {
        return {
          success: false,
          error: '页码和每页大小必须大于0'
        };
      }

      // 调用DAO层查询分销商品
      const result = await productsDAO.queryProducts(query, page, size);
      return result;
    } catch (error) {
      console.error('获取分销商品失败:', error);
      return {
        success: false,
        error: error.message || '获取分销商品失败'
      };
    }
  }
}

module.exports = ProductService;